<!DOCTYPE html><html lang="en"><head><meta charset="UTF-8"><meta http-equiv="X-UA-Compatible" content="IE=edge"><meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1"><meta name="description" content="如何理解“进入内核态”?"><meta name="keywords" content="Linux"><meta name="author" content="LiYang"><meta name="copyright" content="LiYang"><title>如何理解“进入内核态”? | 一条鲤鱼</title><link rel="shortcut icon" href="/melody-favicon.ico"><link rel="stylesheet" href="/css/index.css?version=1.9.0"><link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/font-awesome@latest/css/font-awesome.min.css?version=1.9.0"><meta name="format-detection" content="telephone=no"><meta http-equiv="x-dns-prefetch-control" content="on"><link rel="dns-prefetch" href="https://cdn.jsdelivr.net"><meta http-equiv="Cache-Control" content="no-transform"><meta http-equiv="Cache-Control" content="no-siteapp"><script>var GLOBAL_CONFIG = { 
  root: '/',
  algolia: undefined,
  localSearch: undefined,
  copy: {
    success: 'Copy successfully',
    error: 'Copy error',
    noSupport: 'The browser does not support'
  },
  hexoVersion: '5.4.0'
} </script><meta name="generator" content="Hexo 5.4.0"><link rel="alternate" href="/atom.xml" title="一条鲤鱼" type="application/atom+xml">
</head><body><i class="fa fa-arrow-right" id="toggle-sidebar" aria-hidden="true"></i><div id="sidebar" data-display="true"><div class="toggle-sidebar-info text-center"><span data-toggle="Toggle article">Toggle site</span><hr></div><div class="sidebar-toc"><div class="sidebar-toc__title">Catalog</div><div class="sidebar-toc__progress"><span class="progress-notice">You've read</span><span class="progress-num">0</span><span class="progress-percentage">%</span><div class="sidebar-toc__progress-bar"></div></div><div class="sidebar-toc__content"><ol class="toc"><li class="toc-item toc-level-1"><a class="toc-link" href="#%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E3%80%8C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E3%80%8D%EF%BC%9F"><span class="toc-number">1.</span> <span class="toc-text">如何理解「进入内核态」？</span></a><ol class="toc-child"><li class="toc-item toc-level-2"><a class="toc-link" href="#CPU-%E8%BF%90%E8%A1%8C%E6%9C%BA%E5%88%B6"><span class="toc-number">1.1.</span> <span class="toc-text">CPU 运行机制</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#Intel-CPU-%E5%8E%86%E5%8F%B2%E5%8F%91%E5%B1%95%E5%8F%B2"><span class="toc-number">1.2.</span> <span class="toc-text">Intel CPU 历史发展史</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E5%88%86%E6%AE%B5"><span class="toc-number">1.2.1.</span> <span class="toc-text">分段</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%BF%9D%E6%8A%A4%E6%A8%A1%E5%BC%8F"><span class="toc-number">1.2.2.</span> <span class="toc-text">保护模式</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E7%89%B9%E6%9D%83%E7%BA%A7"><span class="toc-number">1.3.</span> <span class="toc-text">特权级</span></a><ol class="toc-child"><li class="toc-item toc-level-3"><a class="toc-link" href="#%E7%B3%BB%E7%BB%9F%E8%B0%83%E7%94%A8"><span class="toc-number">1.3.1.</span> <span class="toc-text">系统调用</span></a></li><li class="toc-item toc-level-3"><a class="toc-link" href="#%E4%B8%AD%E6%96%AD"><span class="toc-number">1.3.2.</span> <span class="toc-text">中断</span></a></li></ol></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E5%88%86%E6%AE%B5%E5%86%85%E5%AD%98%E7%9A%84%E4%BC%98%E7%BC%BA%E7%82%B9"><span class="toc-number">1.4.</span> <span class="toc-text">分段内存的优缺点</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E5%86%85%E5%AD%98%E5%88%86%E9%A1%B5"><span class="toc-number">1.5.</span> <span class="toc-text">内存分页</span></a></li><li class="toc-item toc-level-2"><a class="toc-link" href="#%E6%80%BB%E7%BB%93"><span class="toc-number">1.6.</span> <span class="toc-text">总结</span></a></li></ol></li></ol></div></div><div class="author-info hide"><div class="author-info__avatar text-center"><img src="/img/avatar.png"></div><div class="author-info__name text-center">LiYang</div><div class="author-info__description text-center"></div><hr><div class="author-info-articles"><a class="author-info-articles__archives article-meta" href="/archives"><span class="pull-left">Articles</span><span class="pull-right">13</span></a><a class="author-info-articles__tags article-meta" href="/tags"><span class="pull-left">Tags</span><span class="pull-right">6</span></a><a class="author-info-articles__categories article-meta" href="/categories"><span class="pull-left">Categories</span><span class="pull-right">7</span></a></div></div></div><div id="content-outer"><div class="no-bg" id="top-container"><div id="page-header"><span class="pull-left"> <a id="site-name" href="/">一条鲤鱼</a></span><i class="fa fa-bars toggle-menu pull-right" aria-hidden="true"></i><span class="pull-right menus">   <a class="site-page" href="/">Home</a><a class="site-page" href="/archives">Archives</a><a class="site-page" href="/tags">Tags</a><a class="site-page" href="/categories">Categories</a></span><span class="pull-right"></span></div><div id="post-info"><div id="post-title">如何理解“进入内核态”?</div><div id="post-meta"><time class="post-meta__date"><i class="fa fa-calendar" aria-hidden="true"></i> 2022-06-20</time><span class="post-meta__separator">|</span><i class="fa fa-inbox post-meta__icon" aria-hidden="true"></i><a class="post-meta__categories" href="/categories/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/">操作系统</a><i class="fa fa-angle-right" aria-hidden="true"></i><i class="fa fa-inbox post-meta__icon" aria-hidden="true"></i><a class="post-meta__categories" href="/categories/%E6%93%8D%E4%BD%9C%E7%B3%BB%E7%BB%9F/Linux/">Linux</a></div></div></div><div class="layout" id="content-inner"><article id="post"><div class="article-container" id="post-content"><h1 id="如何理解「进入内核态」？"><a href="#如何理解「进入内核态」？" class="headerlink" title="如何理解「进入内核态」？"></a>如何理解「进入内核态」？</h1><p>这是个需要很多知识储备才能解答的问题，比如需要了解内存的分段，分页，中断，特权级等机制，信息量比较大。</p>
<p>本文的主要内容包括如下几个部分：</p>
<ul>
<li>CPU 运行机制</li>
<li>Intel CPU 历史发展史<ul>
<li>分段</li>
<li>保护模式</li>
</ul>
</li>
<li>特权级<ul>
<li>系统调用</li>
<li>中断</li>
</ul>
</li>
<li>分段内存的优缺点</li>
<li>内存分页</li>
<li>总结</li>
</ul>
<hr>
<h2 id="CPU-运行机制"><a href="#CPU-运行机制" class="headerlink" title="CPU 运行机制"></a>CPU 运行机制</h2><ul>
<li>CPU 是如何工作的呢？它是根据一条条的机器指令来执行的，而<code>机器指令 = 操作码 + 操作数</code>，操作数主要有三类：寄存器地址、内存地址或立即数（即常量）。</li>
<li>我们所熟悉的<strong>程序就是一堆指令和数据的集合</strong>，当打开程序时，装载器把程序中的指令和数据加载到内存中，然后由 CPU 进行取指执行指令。</li>
<li>在内存中是以字节为基本单位来读写数据的，我们可以<strong>把内存看作是一个个的小格子（一般我们称其为内存单元），而每个小格子是一个字节</strong>，那么对于 B8 0123H 这条指令来说，它在内存中占三字节，如下，CPU 该怎么找到这些格子呢，我们需要给这些格子编号，这些编号也就是我们说的<strong>内存地址</strong>，根据内存地址就是可以定位指令所在位置，从而取出里面的数据</li>
</ul>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640.jpeg" alt="640" style="zoom: 67%;">

<p>CPU 执行指令主要分为以下几个步骤：</p>
<ol>
<li><strong>取指令</strong>，CPU 怎么知道要去取哪条指令呢，它里面有一个 IP 寄存器指向了对应要取的指令的内存地址， 然后这个内存地址会通过<strong>地址总线</strong>找到对应的格子，我们把这个过程称为<strong>寻址</strong>，不难发现<strong>寻址能力决定于地址总线的位宽</strong>，假设地址总线位数为 20 位，那么内存的可寻址空间为 2^20 *  1Byte = 1M，将格子（内存单元）里面的数据（指令）取出来后，再通过<strong>数据总线</strong>发往 CPU 中的指令缓存区（指令寄存器），那么一次能传多少数据呢，<strong>取决于数据总线的位宽</strong>，如果数据总线为 16 位，那么一次可以传 16 bit 也就是两个字节。</li>
<li><strong>译码</strong>：指令缓冲区中的指令经过译码以确定该进行什么操作</li>
<li><strong>执行</strong>：译码后会由控制单元向运算器发送控制指令进行操作（比如执行加减乘除等），执行是由运算器操纵数据也就是操作数进行计算，而操作数保存在存储单元（即片内的缓存和寄存器组）中，由于操作数有可能是内存地址，所以执行中可能需要到内存中获取数据（这个过程称为<strong>访存</strong>），执行后的结果保存在寄存器或<strong>写回</strong>内存中</li>
</ol>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/../../秋招/零碎知识点/如何理解“进入内核态”.assets/640-16557030935303.jpeg" alt="图片" style="zoom:67%;">

<p>​    以指令 mov ax, 0123H 为例，它表示将数据 0123H 存到寄存器 AX 中，在此例中 AX 为 16 位寄存器，一次可以操作 16 位也就是 2 Byte 的数据，所以我们将其称为 16 位 CPU，<strong>CPU 是多少位取决于它一次执行指令的数据带宽，而数据带宽又取决于通用寄存器的位宽。</strong></p>
<ol start="4">
<li>   <strong>更新 IP</strong>：执行完一条指令后,更新 IP 中的值，将其指向下一条指令的起始地址，然后重复步骤 1由以上总结可知<strong>寻址能力与寄存器位数有关。</strong></li>
</ol>
<hr>
<p>接下来我们以执行四条指令为例再来仔细看下 CPU 是如何执行指令的，动图如下：</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/../../秋招/零碎知识点/如何理解“进入内核态”.assets/640-16557032084796.gif" alt="图片" style="zoom:50%;">

<p>看到上面这个动图，可能会发现两个问题</p>
<ol>
<li><strong>前文说指令地址是根据 IP 来获取的吗，但上图显示指令地址却是由「CS 左移四位 + IP」计算而来的，与我们所阐述的指令保存在 IP 寄存器中似乎有些出入，这是怎么回事呢？</strong></li>
<li><strong>动图显示的地址是真实物理地址，这样进程之间可以互相访问/改写对方的物理地址，显然是不安全的，那如何才能做到安全访问或者说进程间内存的隔离呢</strong></li>
</ol>
<p>接着往下看。。。</p>
<h2 id="Intel-CPU-历史发展史"><a href="#Intel-CPU-历史发展史" class="headerlink" title="Intel CPU 历史发展史"></a>Intel CPU 历史发展史</h2><p>1971 年世界上第一块 4 位 CPU-4004 微处理器横空出世，1974 年 Intel 研发成功了 8 位 CPU-8080，这两款 CPU <strong>都是使用的绝对物理地址来寻址的</strong>，指令地址只存在于 IP 寄存器中（即只使用 IP 寄存器即可确定内存地址）。由于是使用绝对物理地址寻址，也就意味着进程之间的内存数据可能会互相覆盖，很不安全，所以<strong>这两者只支持单进程</strong></p>
<h3 id="分段"><a href="#分段" class="headerlink" title="分段"></a>分段</h3><p>1978 年英特尔又研究成功了第一款 16  位 CPU - 8086，这款 CPU 可以说是 x86 系列的鼻祖了，设计了 16 位的寄存器和 20 位的地址总线，所以内存地址可以达到 2^20 Byte 即 1M，极大地扩展了地址空间，但是问题来了，由于寄存器只有 16 位，那么 16 位的 IP 寄存器如何能寻址 20 位的地址呢，首先 Intel 工程师设计了一种<strong>分段的方法</strong>：1M 内存可以分为 16 个大小为 <strong>64 K 的段</strong>，那么内存地址就可以由「段的起始地址（也叫<strong>段基址</strong>） + <strong>段内偏移</strong>（IP 寄存器中的值）」组成，对于进程说只需要关心 4 个段 ，<code>代码段</code>，<code>数据段</code>，<code>堆栈段</code>，<code>附加段</code>，这几个段的段基址分别保存在 CS，DS，SS，ES 这四个寄存器中</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-16557034726389.jpeg" alt="图片" style="zoom:50%;">

<p>这四个寄存器也是 16 位，那怎么访问 20 位的内存地址呢，实现也很简单，将每个寄存器的值左移四位，然后再加上段内偏移即为寻址地址，CPU 都是取代码段 中的指令来执行的，我们以代码段内的寻址为例来计算内存地址，指令的地址 = CS &lt;&lt; 4 + IP ，这种方式做到了 20 位的寻址，只要改变 CS，IP 的值，即可实现在 0 到最大地址 0xFFFFF 全部 20 位地址的寻址</p>
<p>举个例子：假设 CS 存的数据为 0x2000,IP 为 0x0003,那么对应的指令地址为</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570353052112.jpeg" alt="图片" style="zoom:50%;">

<p>图示为真实的物理地址计算方式，从中可知， CS 其实保存的是真实物理地址的高 16 位。</p>
<p><strong>分段的初衷是为了解决寻址问题</strong>，但本质上段寄存器中保存的还是真实物理地址的段基础，且可以随意指定，所以它也无法支持多进程，因为这意味着进程可以随意修改 CS：IP 将其指向任意地址，很可能会覆盖正在运行的其他进程的内存，造成灾难性后果。</p>
<p>我们把这种使用真实物理地址且未加任何限制的寻址方式称为<strong>实模式</strong>（real mode，即实际地址模式）</p>
<hr>
<h3 id="保护模式"><a href="#保护模式" class="headerlink" title="保护模式"></a>保护模式</h3><p>实模式上的物理地址由段寄存器中的段基址:IP 计算而来，而段基址可由用户随意指定，显然非常不安全，于是 Intel 在之后推出了 80286 中启用了<strong>保护模式</strong>，这个保护是怎么做的呢</p>
<p>首先<strong>段寄存器保存的不再是段基址了，而是段选择子（Selector）</strong>，其结构如下</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570363170415.jpeg" alt="图片" style="zoom:50%;">

<p>其中第 3 到 15 位保存的是描述符索引，此索引会根据 TI 的值是 0 还是  1 来选择是到 GDT（全局描述符表，一般也称为段表）还是 LDT 来找段描述符，段描述符保存的是段基址和段长度，找到段基址后再加上保存在 IP 寄存器中的段偏移量即为物理地址，段描述符的长度统一为 8 个字节，而 GDT/LDT 表的基地址保存在 gdtr/ldtr 寄存器中，以 GDT （此时 TI 值为 0）为例来看看此时 CPU 是如何寻址的</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/../../秋招/零碎知识点/如何理解“进入内核态”.assets/640-165570369371318.jpeg" alt="图片" style="zoom: 50%;">

<p>可以看到程序中的地址是由段选择子：段内偏移量组成的，也叫<strong>逻辑地址</strong>，在只有分段内存管理的情况下它也被称为<strong>虚拟内存</strong></p>
<p>GDT 及段描述符的分配都是由操作系统管理的，进程也无法更新 CS 等寄存器中值，这样就避免了直接操作其他进程以及自身的物理地址，达到了保护内存的效果，从而为多进程运行提供了可能，我们把这种寻址方式称为<strong>保护模式</strong></p>
<p>那么保护模式是如何实现的呢，细心的你可能发现了上图中在段选择子和段描述符中里出现了 <strong>RPL</strong> 和 <strong>DPL</strong> 这两个新名词，这两个表示啥意思呢？这就涉及到一个概念：<strong>特权级</strong></p>
<h2 id="特权级"><a href="#特权级" class="headerlink" title="特权级"></a>特权级</h2><p>我们知道 CPU 是根据机器指令来执行的，但这些指令有些是非常危险的，比如<strong>清内存</strong>，<strong>置时钟</strong>，<strong>分配系统资源</strong>等，这些指令显然不能让普通的进程随意执行，应该始终控制在操作系统中执行，所以要把操作系统和普通的用户进程区分开来。</p>
<p>我们把一个进程的虚拟地址划分为两个空间，<strong>用户空间</strong>和<strong>内核空间</strong>，用户空间即普通进程所处空间，内核空间即操作系统所处空间。</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570798535721.jpeg" alt="图片" style="zoom:50%;">

<p>当 CPU 运行于用户空间（执行用户空间的指令）时，它处于<strong>用户态</strong>，只能执行普通的 CPU 指令 ，当 CPU 运行于内核空间（执行内核空间的指令）时，它处于<strong>内核态</strong>，可以执行清内存，置时钟，读写文件等特权指令，那怎么区分 CPU 是在用户态还是内核态呢，<strong>CPU 定义了四个特权等级</strong>，如下，从 0 到 3，特权等级依次递减，当特权级为 0 时，CPU 处于内核态，可以执行任何指令，当特权级为 3 时，CPU 处于用户态，<strong>在 Linux 中只用了 Ring  0，Ring 3 两个特权等级</strong>。</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570812564924.jpeg" alt="图片" style="zoom:67%;">

<p>那么问题来了，怎么知道 CPU 处于哪一个特权等级呢，还记得上文中我们提到的段选择子吗？</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570814139727.jpeg" alt="图片" style="zoom:50%;">

<p>其中的 <strong>RPL 表示请求特权（(Requested privilege level)）</strong>我们把当前保存于 CS 段寄存器的段选择子中的 RPL 称为 <strong>CPL（current priviledge level），即当前特权等级</strong>，可以看到 RPL 有两位，刚好对应着 0,1,2,3 四个特权级，而上文提到的 <strong>DPL 表示段描述符中的特权等级（Descriptor privilege level）</strong>知道了这两个概念也就知道保护模式的实现原理了，CPU 会在两个关键点上对内存进行保护</p>
<ol>
<li>目标段选择子被加载时</li>
<li>当通过线性地址（在只有段式内存情况下，线性地址为物理地址）访问一个内存页时。由此可见，保护也反映在内存地址转换的过程之中，既包括分段又包括分页（后文分提到分页）</li>
</ol>
<p><strong>CPU 是怎么保护内存的呢，它会对 CPL，RPL，DPL 进行如下检查</strong></p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570827870530.png" alt="图片" style="zoom: 67%;">

<p>只有 <strong>CPL &lt;= DPL 且 RPL &lt;= DPL</strong> 时，才会加载目标代码段执行，否则会报<strong>一般保护异常 （General-protection exception）</strong></p>
<p>那么特权等级（也就是 CPL）是怎么变化的呢，我们之前说了 CPU 运行于用户空间时，处于用户态，特权等级为 3，运行于内核空间时，处于内核态，特权等级为 0，所以也可以换个问法 CPU 是如何从用户空间切换到内核空间或者从内核空间切换到用户空间的，这就涉及到一个概念：<strong>系统调用</strong>。</p>
<h3 id="系统调用"><a href="#系统调用" class="headerlink" title="系统调用"></a>系统调用</h3><p>我们知道用户进程虽然不能执行特权指令，但有时候也需要执行一些读写文件，发送网络包等操作，而这些操作又只能让操作系统来执行，那该怎么办呢，可以让<strong>操作系统提供接口，让用户进程来调用</strong>即可，我们把这种方式叫做<strong>系统调用</strong>，系统调用可以直接由应用程序调用，或者通过调用一些公用函数库或 shell（这些函数库或 shell 都封装了系统调用接口）等也可以达到间接调用系统调用的目的。通过系统调用，应用程序实现了<strong>陷入（trap）内核态</strong>的目的，这样就从用户态切换到了内核态中，如下</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570843564333.jpeg" alt="图片" style="zoom: 67%;">

<p>那么系统调用又是怎么实现的呢，主要是靠<strong>中断</strong>实现的，接下来我们就来了解一下什么是中断</p>
<h3 id="中断"><a href="#中断" class="headerlink" title="中断"></a>中断</h3><p>陷入内核态的系统调用主要是通过一种 <strong>trap gate</strong>（陷阱门）来实现的，它其实是<strong>软件中断</strong>的一种，由 CPU 主动触发给自己一个中断向量号，然后 CPU 根据此中断向量号就可以去中断向量表找到对应的<strong>门描述符</strong>，门描述符与 GDT 中的段描述符相似，也是 8 个字节，门描述符中包含段选择子，段内偏移，DPL 等字段 ，然后再根据段选择子去 GDT（或者 LDT，下图以 GDT 为例） 中查找对应的段描述符，再找到段基地址，然后根据中断描述符表的段内偏移即可找到中断处理例程的入口点,整个中断处理流程如下</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570856127136.jpeg" alt="图片" style="zoom: 67%;">

<p>当然了，不是随便发一个中断向量都能被执行，只有满足一定条件的中断才允许被普通的应用程序调用，从发出软件中断再到执行中断对应的代码段会做如下的检查</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570864262139.jpeg" alt="图片" style="zoom:50%;">

<p>一般应用程序发出软件中断对应的向量号是大家熟悉的 int 0x80（int 代表 interrupt），它的门描述符中的 DPL 为 3,所以能被所有的用户程序调用，而它对应的目标代码段描述符中的 DPL 为 0，所以当通过中断门检查后（即 CPL &lt;= 门描述符中的 DPL 成立），CPU 就会将 CS 寄存器中的 RPL（3） 替换为目标代码段描述符的 DPL（0），替换后的 CPL 也就变成了 0，通过这种方式完成了从用户态到内核态的替换，当中断代码执行后执行 iret 指令又会切换回用户态</p>
<p><strong>另外当执行中断程序时，还需要首先把当前用户进程中对应的堆栈，返回地址等信息保存，以便切回到用户态时能恢复现场</strong></p>
<p>可以看到 int 80h 这种软件中断的执行又是检查特权级，又是从用户态切换到内核态，又是保存寄存器的值，可谓是非常的耗时，光看一下以下图示就知道像 int 0x80 这样的软件中断开销是有多大了</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165570876179242.png" alt="图片" style="zoom:67%;">

<p>所以后来又开发出了 <strong>SYSENTER<code>/</code>SYSCALL</strong> 这样快速系统调用的指令，它们取消了权限检查，也不需要在中断描述表（Interrupt Descriptor Table、IDT）中查找系统调用对应的执行过程，也不需要保存堆栈和返回地址等信息，而是直接进入<em>CPL 0</em>，并将新值加载到与代码和堆栈有关的寄存器当中（cs，eip，ss 和 esp），所以极大地提升了性能。</p>
<hr>
<h2 id="分段内存的优缺点"><a href="#分段内存的优缺点" class="headerlink" title="分段内存的优缺点"></a>分段内存的优缺点</h2><p>使用了保护模式后，程序员就可以在代码中使用了<strong>段选择子：段偏移量</strong>的方式来寻址，这不仅让多进程运行成为了可能，而且也解放了程序员的生产力，<strong>我们完全可以认为程序拥有所有的内存空间（虚拟空间），因为段选择子是由操作系统分配的，只要操作系统保证不同进程的段的虚拟空间映射到不同的物理空间上，不要重叠即可，也就是说虽然各个程序的虚拟空间是一样的，但由于它们映射的物理地址是不同且不重叠的，所以是能正常工作的，但是为了方便映射，一般要求在物理空间中分配的段是连续的（这样只要维护映射关系的起始地址和对应的空间大小即可）</strong></p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573477906445.jpeg" alt="图片" style="zoom: 67%;">

<p>但段式内存管理缺点也很明显：内存碎片可能很大，举个例子</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573479129248.jpeg" alt="图片" style="zoom:67%;">

<p>如上图示，连续加载了三个程序到内存中，如果把 Chrome 关闭了，此时内存中有两段 128 M的空闲内存，但如果此时要加载一个 192 M 的程序 X 却有心无力了 ，因为段式内存需要划分出一块<strong>连续的</strong>内存空间，此时你可以选择把占 256 M 的 Python 程序先 swap 到磁盘中，然后紧跟着 512 M 内存的后面划分出 256 M 内存，再给 Python 程序 swap 到这块物理内存中，这样就腾出了连续的 256 M 内存，从而可以加载程序 X 了，但这种频繁地将几十上百兆内存与硬盘进行 swap 显然会对性能造成严重的影响，毕竟谁都知道内存和硬盘的读写速度可是一个天上一个地上，如果一定要交换，能否每次 swap 得能少一点，比如只有几 K，这样就能满足我们的需求，<strong>分页内存管理</strong>就诞生了</p>
<h2 id="内存分页"><a href="#内存分页" class="headerlink" title="内存分页"></a>内存分页</h2><p>1985 年 intel 推出了 32 位处理器 80386，也是首款支持分页内存的 CPU</p>
<p>和分段这样连续分配一整段的空间给程序相比，<strong>分页是把整个物理空间切成一段段固定尺寸的大小</strong>，当然为了映射，<strong>虚拟地址也需要切成一段段固定尺寸的大小</strong>，这种固定尺寸的大小我们一般称其为页，<strong>在 Linux 中一般每页的大小为 4KB，这样虚拟地址和物理地址就通过页来映射起来了</strong></p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573494365051.jpeg" alt="图片" style="zoom: 67%;">

<p>当然了<strong>这种映射关系是需要一个映射表来记录的，这样才能把虚拟地址映射到物理内存中，给定一个虚拟地址，它最终肯定在某个物理页内，所以虚拟地址一般由「页号+页内偏移」组成，而映射表项需要包含物理内存的页号，这样只要将页号对应起来，再加上页内偏移，即可获取最终的物理内存。</strong></p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573511291954.jpeg" alt="图片" style="zoom:67%;">

<p>于是问题来了，映射表（也称页表）该怎么设计呢,我们以 32 位虚拟地址位置来看看，假设页大小为 4K（2^12），那么至少需要 2^20 也就是 100 多万个页表项才能完全覆盖所有的虚拟地址，假设每一个页表项 4 个字节，那就意味着为一个进程的虚拟地址就需要准备 2^20 * 4 B = 4 M 的页表大小，如果有 100 个进程，就意味着光是页表就要占用 400M 的空间了，这显然是非常巨大的开销，那该怎么解决这个页表空间占用巨大的问题呢？</p>
<p>我们注意到现在的做法是一次性为进程分配了占用其所有虚拟空间的页表项，但实际上一个进程根本用不到这么巨大的虚拟空间，所以这种分配方式无疑导致很多分配的页表项白白浪费了，那该怎么办，答案是<strong>分级管理，等真正需要分配物理空间的时候再分配</strong>，其实大家可以想想我们熟悉的 windows 是怎么分配的，是不是一开始只分配了 C 盘，D盘，E盘，等要存储的时候，先确定是哪个盘，再在这个盘下分配目录，然后再把文件存到这个目录下，并不会一开始就把所有盘的空间给分配完的。</p>
<p>同样的道理，以 32 位虚拟地址为例，我们也可以对页表进行分级管理, 页表项 2^20 = 2^10 * 2^10 = 1024 * 1024，我们把一个页表分成两级页表，第一级页表 1024 项，每一项都指向一个包含有 1024 个页表项的二级页表</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573551550457.jpeg" alt="图片" style="zoom:50%;">

<p>这样<strong>只有在一级页表中的页表项被分配的时候才会分配二级页表，极大的节省了空间</strong>，我们简单算下，假设 4G 的虚拟空间进程只用了 20%（已经很大了，大部分用不到这么多），那么由于一级页表空间为 1024 *4 = 4K，总的页表空间为 4K+ 0.2 * 4M = 0.804M，相比于原来的 4M 是个巨大的提升！</p>
<p>那么<strong>对于分页保护模式又是如何起作用的呢</strong>，同样以 32 位为例，它的二级页表项（也称 page table entry）其实是以下结构</p>
<img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573556006364.jpeg" alt="图片" style="zoom: 67%;">

<p>注意第三位（也就是 2 对应的位置）有个 <strong>U/S，它其实就是代表特权级</strong>，表示的是用户/超级用户标志。为 <strong>1 时，允许所有特权级别的程序访问；为 0 时，仅允许特权级为0、1、2（Linux 中没有 1，2）的程序（也就是内核）访问。</strong>页目录中的这个位对其所映射的所有页面起作用</p>
<p>既然分页这么好，那么分段是不是可以去掉了呢，理论上确实可以，但 Intel 的 CPU 严格执行了 backward compatibility（回溯兼容），也就是说最新的 CPU 永远可以运行针对早期 CPU 开发的程序，否则早期的程序就得针对新 CPU 架构重新开发了（早期程序针对的是 CPU 的段式管理进行开发），这无论对用户还是开发者都是不能接受的（别忘了安腾死亡的一大原因就是由于不兼容之前版本的指令），兼容性虽然意味着每款新的 CPU 都得兼容老的指令，所背的历史包袱越来越重，但对程序来说能运行肯定比重新开发好，所以既然早期的 CPU 支持段，那么自从 80386 开始的所有 CPU 也都得支持段，而分页反而是可选的，也就意味着这些 <strong>CPU 的内存管理都是段页式管理，逻辑地址要先经过段式管理单元转成线性地址（也称虚拟地址），然后再经过页式管理单元转成物理内存</strong>，如下</p>
<p><img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573569185867-165573569467269.jpeg" alt="640-165573569185867-165573569467269"></p>
<p>在 Linux 中，虽然也是段页式内存管理，但它统一把 CS，DS，SS，ES 的段基址设置为了 0，段界限也设置为了整个虚拟内存的长度，所有段都分布在同一个地址空间，这种内存模式也叫<strong>平坦内存模型（flat memory model）</strong></p>
<p><img src="/2022/06/20/%E5%A6%82%E4%BD%95%E7%90%86%E8%A7%A3%E2%80%9C%E8%BF%9B%E5%85%A5%E5%86%85%E6%A0%B8%E6%80%81%E2%80%9D/640-165573570355770-165573570501972.png" alt="640-165573570355770-165573570501972"></p>
<p>我们知道逻辑地址由段选择子：段内偏移地址组成，既然段选择子指向的段基地址为 0，那也就意味着段内偏移地址即为即为线性地址（也就是虚拟地址），由此可知 <strong>Linux 中所有程序的代码都使用了虚拟地址，通过这种方式巧妙地绕开了分段管理，分段只起到了访问控制和权限的作用（别忘了各种权限检查依赖 DPL，RPL 等特权字段，特权极转移也依赖于段选择子中的 DPL 来切换的）</strong></p>
<h2 id="总结"><a href="#总结" class="headerlink" title="总结"></a>总结</h2><p>简单总结一下，CPU 诞生之后，使用的绝对物理内存来寻址（也就是实模式），随后随着 8086 的诞生，由于工艺的原因，虽然地址总线是 20 位，但寄存器却只有 16 位，一个难题出现了，16 位的寄存器该怎么寻址 20 位的内存地址呢，于是段的概念被提出了，段的出现虽然解决了寻址问题，但本质上 CS &lt;&lt; 4 + IP 的寻址方式依然还是绝对物理地址，这样的话由于地址会互相覆盖，显然无法做到多进程运行，于是<strong>保护模式</strong>被提出了，保护就是为了物理内存免受非法访问，于是用户空间，内核空间，特权级也被提出来了，段寄存器里保存的不再是段基址，而是<strong>段选择子</strong>，由操作系统分配，用户也无法随意修改段选择子，必须通过中断的形式才能从用户态陷入内核态，中断执行的过程也需要经历特权级的检查，检查通过之后特权级从 3 切换到了 0，于是就可以放心合法的执行特权指令了。可以看到，通过操作系统分配段选择子+中断的方式内存得到了有效保护，但是分段可能造成内存碎片过大以致频繁 swap 会影响性能的问题，于是分页出现了，保护模式+分页终于可以让多进程，高效调度成为了可能。</p>
<blockquote>
<p> 注：参考自程序员cxuan的文章《非常硬核的解释！》</p>
</blockquote>
</div></article><div class="post-copyright"><div class="post-copyright__author"><span class="post-copyright-meta">Author: </span><span class="post-copyright-info"><a href="mailto:undefined">LiYang</a></span></div><div class="post-copyright__type"><span class="post-copyright-meta">Link: </span><span class="post-copyright-info"><a href="http://example.com/2022/06/20/如何理解“进入内核态”/">http://example.com/2022/06/20/如何理解“进入内核态”/</a></span></div><div class="post-copyright__notice"><span class="post-copyright-meta">Copyright Notice: </span><span class="post-copyright-info">All articles in this blog are licensed under <a target="_blank" rel="noopener" href="https://creativecommons.org/licenses/by-nc-sa/4.0/">CC BY-NC-SA 4.0</a> unless stating additionally.</span></div></div><div class="post-meta__tag-list"><a class="post-meta__tags" href="/tags/Linux/">Linux</a></div><nav id="pagination"><div class="prev-post pull-left"><a href="/2022/11/07/gittest/"><i class="fa fa-chevron-left">  </i><span>gittest</span></a></div><div class="next-post pull-right"><a href="/2022/05/13/C-%E4%B8%AD%E7%9A%84%E5%86%85%E5%AD%98%E6%B3%84%E6%BC%8F/"><span>C++中的内存泄漏</span><i class="fa fa-chevron-right"></i></a></div></nav></div></div><footer><div class="layout" id="footer"><div class="copyright">&copy;2013 - 2022 By LiYang</div><div class="framework-info"><span>Driven - </span><a target="_blank" rel="noopener" href="http://hexo.io"><span>Hexo</span></a><span class="footer-separator">|</span><span>Theme - </span><a target="_blank" rel="noopener" href="https://github.com/Molunerfinn/hexo-theme-melody"><span>Melody</span></a></div><div class="busuanzi"><script async src="//busuanzi.ibruce.info/busuanzi/2.3/busuanzi.pure.mini.js"></script><span id="busuanzi_container_page_pv"><i class="fa fa-file"></i><span id="busuanzi_value_page_pv"></span><span></span></span></div></div></footer><i class="fa fa-arrow-up" id="go-up" aria-hidden="true"></i><script src="https://cdn.jsdelivr.net/npm/animejs@latest/anime.min.js"></script><script src="https://cdn.jsdelivr.net/npm/jquery@latest/dist/jquery.min.js"></script><script src="https://cdn.jsdelivr.net/npm/@fancyapps/fancybox@latest/dist/jquery.fancybox.min.js"></script><script src="https://cdn.jsdelivr.net/npm/velocity-animate@latest/velocity.min.js"></script><script src="https://cdn.jsdelivr.net/npm/velocity-ui-pack@latest/velocity.ui.min.js"></script><script src="/js/utils.js?version=1.9.0"></script><script src="/js/fancybox.js?version=1.9.0"></script><script src="/js/sidebar.js?version=1.9.0"></script><script src="/js/copy.js?version=1.9.0"></script><script src="/js/fireworks.js?version=1.9.0"></script><script src="/js/transition.js?version=1.9.0"></script><script src="/js/scroll.js?version=1.9.0"></script><script src="/js/head.js?version=1.9.0"></script><script>if(/Android|webOS|iPhone|iPod|iPad|BlackBerry/i.test(navigator.userAgent)) {
  $('#nav').addClass('is-mobile')
  $('footer').addClass('is-mobile')
  $('#top-container').addClass('is-mobile')
}</script></body></html>